﻿using System;
using Itau.IM.Carimbador.Contract;
using Itau.IM.Carimbador.Interface;
using Itau.IM.Common.Interface;
using Itau.IM.Common.Logging;
using Itau.IM.Common.Mainframe.Communication;
using Itau.IM.Common.Utility;
using Itau.IM.Common.Mainframe.Book;
using Itau.IM.Common.Mainframe.Constants;

namespace Itau.IM.Carimbador.Implementation
{
    /// <summary>
    /// Implementação do serviço TransferPrice
    /// </summary>
    public class TransferPriceImpl : ITransferPrice
    {
        #region Métodos

        /// <summary>
        /// Método responsável por tratar o horário do campo DataHoraOperacao
        /// </summary>
        /// <param name="dataHora_">Data e Horário de Operação</param>
        /// <returns></returns>
        private DateTime TratarHorarioNulo(DateTime dataHora_)
        {
            if (dataHora_.Hour == 0 && dataHora_.Minute == 0 && dataHora_.Second == 0)
            {
                return new DateTime(dataHora_.Year, dataHora_.Month, dataHora_.Day, 23, 59, 59);
            }

            return dataHora_;
        }

        /// <summary>
        /// Método responsável pela obtenção de pontos de uma curva regular, sem prazo específico
        /// </summary>
        /// <param name="request_">Requisição</param>
        /// <returns>Resposta</returns>
        public ConsultarRegularSemPrazoResponse ConsultarRegularSemPrazo(ConsultarRegularSemPrazoRequest request_)
        {
            string nomeRotina = "TransferPrice";

            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do objeto de requisição");

                request_.DataHoraOperacao = TratarHorarioNulo(request_.DataHoraOperacao);

                string bookEntrada = BookSerializer.Serialize(request_);

                //log.LogInfo("Executando a transação IMS");
                //log.LogInfo("Book de entrada: {0}{1}", Environment.NewLine, bookEntrada);

                string mock = Configuration.GetSetting("Mock.ConsultarRegularSemPrazo");

                string bookSaida = (mock != null) ? mock : new ImsTransaction(nomeRotina, ConfigurationConstants.BOOK_SEGMENTADO).Invoke(bookEntrada);

                //log.LogInfo("Book de saída: {0}{1}", Environment.NewLine, bookSaida);

                //log.LogInfo("Parse do objeto de resposta");

                return (ConsultarRegularSemPrazoResponse)BookSerializer.Deserialize(bookSaida, typeof(ConsultarRegularSemPrazoResponse));
            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarRegularSemPrazo': " + e.Message, e);
            }
        }

        /// <summary>
        /// Método responsável pela obtenção um único pontos de uma curva regular, com prazo específico
        /// </summary>
        /// <param name="request_">Requisição</param>
        /// <returns>Resposta</returns>
        public ConsultarRegularSemPrazoResponse ConsultarRegularSemPrazoGet(string request_)
        {
            //string nomeRotina = "TransferPrice";
            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do XML de requisição");

                ConsultarRegularSemPrazoRequest request = Serialization.Deserialize<ConsultarRegularSemPrazoRequest>(request_);

                //log.LogInfo("Executando método principal");

                return ConsultarRegularSemPrazo(request);
            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarRegularSemPrazo': " + e.Message, e);
            }
        }

        /// <summary>
        /// Método responsável pela obtenção um único pontos de uma curva regular, com prazo específico
        /// </summary>
        /// <param name="request_">Requisição</param>
        /// <returns>Resposta</returns>
        public ConsultarRegularComPrazoResponse ConsultarRegularComPrazo(ConsultarRegularComPrazoRequest request_)
        {
            string nomeRotina = "TransferPrice";

            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do objeto de requisição");

                request_.DataHoraOperacao = TratarHorarioNulo(request_.DataHoraOperacao);

                string bookEntrada = BookSerializer.Serialize(request_);

                //log.LogInfo("Executando a transação IMS");
                //log.LogInfo("Book de entrada: {0}{1}", Environment.NewLine, bookEntrada);

                string mock = Configuration.GetSetting("Mock.ConsultarRegularComPrazo");

                string bookSaida = (mock != null) ? mock : new ImsTransaction(nomeRotina, ConfigurationConstants.BOOK_SEGMENTADO).Invoke(bookEntrada);

                //log.LogInfo("Book de saída: {0}{1}", Environment.NewLine, bookSaida);

                //log.LogInfo("Parse do objeto de resposta");

                return (ConsultarRegularComPrazoResponse)BookSerializer.Deserialize(bookSaida, typeof(ConsultarRegularComPrazoResponse));
            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarRegularComPrazo': " + e.Message, e);
            }
        }

        /// <summary>
        /// Método responsável pela obtenção um único pontos de uma curva regular, com prazo específico
        /// </summary>
        /// <param name="request_">Requisição</param>
        /// <returns>Resposta</returns>
        public ConsultarRegularComPrazoResponse ConsultarRegularComPrazoGet(string request_)
        {
            //string nomeRotina = "TransferPrice";

            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do XML de requisição");

                ConsultarRegularComPrazoRequest request = Serialization.Deserialize<ConsultarRegularComPrazoRequest>(request_);

                //log.LogInfo("Executando método principal");

                return ConsultarRegularComPrazo(request);
            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarRegularComPrazo': " + e.Message, e);
            }
        }

        /// <summary>
        /// Método responsável pela obtenção de pontos de uma curva irregular
        /// </summary>
        /// <param name="request_">Requisição</param>
        /// <returns>Resposta</returns>
        public ConsultarIrregularResponse ConsultarIrregular(ConsultarIrregularRequest request_)
        {
            string nomeRotina = "TransferPrice";

            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do objeto de requisição");

                request_.DataHoraOperacao = TratarHorarioNulo(request_.DataHoraOperacao);

                string bookEntrada = BookSerializer.Serialize(request_);

                //log.LogInfo("Executando a transação IMS");
                //log.LogInfo("Book de entrada: {0}{1}", Environment.NewLine, bookEntrada);

                string bookSaida = new ImsTransaction(nomeRotina, ConfigurationConstants.BOOK_SEGMENTADO).Invoke(bookEntrada);

                //log.LogInfo("Book de saída: {0}{1}", Environment.NewLine, bookSaida);

                //log.LogInfo("Parse do objeto de resposta");

                return (ConsultarIrregularResponse)BookSerializer.Deserialize(bookSaida, typeof(ConsultarIrregularResponse));

            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarIrregular': " + e.Message, e);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="request_"></param>
        /// <returns></returns>
        public ConsultarTaxaTransferPriceResponse ConsultarTaxaTransferPrice(ConsultarTaxaTransferPriceRequest request_)
        {
            string nomeRotina = "TransferPrice";

            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do objeto de requisição");

                request_.DataHoraOperacao = TratarHorarioNulo(request_.DataHoraOperacao);

                string bookEntrada = BookSerializer.Serialize(request_);

                //log.LogInfo("Executando a transação IMS");
                //log.LogInfo("Book de entrada: {0}{1}", Environment.NewLine, bookEntrada);

                string bookSaida = new ImsTransaction(nomeRotina, ConfigurationConstants.BOOK_UNIFICADO).Invoke(bookEntrada);

                System.IO.StreamWriter strFile = System.IO.File.CreateText("C:\\string.txt");
                strFile.WriteLine("Entrada:");
                strFile.WriteLine("\"" + bookEntrada + "\"");
                strFile.WriteLine("Saida:");
                strFile.WriteLine("\"" + bookSaida + "\"");
                strFile.Close();
                //log.LogInfo("Book de saída: {0}{1}", Environment.NewLine, bookSaida);

                //log.LogInfo("Parse do objeto de resposta");

                return (ConsultarTaxaTransferPriceResponse)BookSerializer.Deserialize(bookSaida, typeof(ConsultarTaxaTransferPriceResponse));

            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarTaxaTransferPriceResponse': " + e.Message, e);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="request_"></param>
        /// <returns></returns>
        public ConsultarTaxaTransferPriceResponse ConsultarTaxaTransferPriceGet(string request_)
        {

            //string nomeRotina = "TransferPrice";
            //ILog log = new LogFile(nomeRotina);

            try
            {
                //log.LogInfo("Parse do XML de requisição");

                ConsultarTaxaTransferPriceRequest request = Serialization.Deserialize<ConsultarTaxaTransferPriceRequest>(request_);

                //log.LogInfo("Executando método principal");

                return ConsultarTaxaTransferPrice(request);
            }
            catch (Exception e)
            {
                //log.LogError(e);
                throw new Exception("Erro durante a execução do método 'ConsultarRegularComPrazo': " + e.Message, e);
            }
        }

        #endregion Métodos
    }
}